home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / raid / md_k.h < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-09  |  11.9 KB  |  399 lines
  1. /*
  2.    md_k.h : kernel internal structure of the Linux MD driver
  3.           Copyright (C) 1996-98 Ingo Molnar, Gadi Oxman
  4.       
  5.    This program is free software; you can redistribute it and/or modify
  6.    it under the terms of the GNU General Public License as published by
  7.    the Free Software Foundation; either version 2, or (at your option)
  8.    any later version.
  9.    
  10.    You should have received a copy of the GNU General Public License
  11.    (for example /usr/src/linux/COPYING); if not, write to the Free
  12.    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
  13. */
  14.  
  15. #ifndef _MD_K_H
  16. #define _MD_K_H
  17.  
  18. /* and dm-bio-list.h is not under include/linux because.... ??? */
  19. #include "../../../drivers/md/dm-bio-list.h"
  20.  
  21. #ifdef CONFIG_BLOCK
  22.  
  23. #define    LEVEL_MULTIPATH        (-4)
  24. #define    LEVEL_LINEAR        (-1)
  25. #define    LEVEL_FAULTY        (-5)
  26.  
  27. /* we need a value for 'no level specified' and 0
  28.  * means 'raid0', so we need something else.  This is
  29.  * for internal use only
  30.  */
  31. #define    LEVEL_NONE        (-1000000)
  32.  
  33. #define MaxSector (~(sector_t)0)
  34.  
  35. typedef struct mddev_s mddev_t;
  36. typedef struct mdk_rdev_s mdk_rdev_t;
  37.  
  38. /*
  39.  * options passed in raidrun:
  40.  */
  41.  
  42. /* Currently this must fit in an 'int' */
  43. #define MAX_CHUNK_SIZE (1<<30)
  44.  
  45. /*
  46.  * MD's 'extended' device
  47.  */
  48. struct mdk_rdev_s
  49. {
  50.     struct list_head same_set;    /* RAID devices within the same set */
  51.  
  52.     sector_t size;            /* Device size (in blocks) */
  53.     mddev_t *mddev;            /* RAID array if running */
  54.     long last_events;        /* IO event timestamp */
  55.  
  56.     struct block_device *bdev;    /* block device handle */
  57.  
  58.     struct page    *sb_page;
  59.     int        sb_loaded;
  60.     __u64        sb_events;
  61.     sector_t    data_offset;    /* start of data in array */
  62.     sector_t     sb_start;    /* offset of the super block (in 512byte sectors) */
  63.     int        sb_size;    /* bytes in the superblock */
  64.     int        preferred_minor;    /* autorun support */
  65.  
  66.     struct kobject    kobj;
  67.  
  68.     /* A device can be in one of three states based on two flags:
  69.      * Not working:   faulty==1 in_sync==0
  70.      * Fully working: faulty==0 in_sync==1
  71.      * Working, but not
  72.      * in sync with array
  73.      *                faulty==0 in_sync==0
  74.      *
  75.      * It can never have faulty==1, in_sync==1
  76.      * This reduces the burden of testing multiple flags in many cases
  77.      */
  78.  
  79.     unsigned long    flags;
  80. #define    Faulty        1        /* device is known to have a fault */
  81. #define    In_sync        2        /* device is in_sync with rest of array */
  82. #define    WriteMostly    4        /* Avoid reading if at all possible */
  83. #define    BarriersNotsupp    5        /* BIO_RW_BARRIER is not supported */
  84. #define    AllReserved    6        /* If whole device is reserved for
  85.                      * one array */
  86. #define    AutoDetected    7        /* added by auto-detect */
  87. #define Blocked        8        /* An error occured on an externally
  88.                      * managed array, don't allow writes
  89.                      * until it is cleared */
  90. #define StateChanged    9        /* Faulty or Blocked has changed during
  91.                      * interrupt, so it needs to be
  92.                      * notified by the thread */
  93.     wait_queue_head_t blocked_wait;
  94.  
  95.     int desc_nr;            /* descriptor index in the superblock */
  96.     int raid_disk;            /* role of device in array */
  97.     int saved_raid_disk;        /* role that device used to have in the
  98.                      * array and could again if we did a partial
  99.                      * resync from the bitmap
  100.                      */
  101.     sector_t    recovery_offset;/* If this device has been partially
  102.                      * recovered, this is where we were
  103.                      * up to.
  104.                      */
  105.  
  106.     atomic_t    nr_pending;    /* number of pending requests.
  107.                      * only maintained for arrays that
  108.                      * support hot removal
  109.                      */
  110.     atomic_t    read_errors;    /* number of consecutive read errors that
  111.                      * we have tried to ignore.
  112.                      */
  113.     atomic_t    corrected_errors; /* number of corrected read errors,
  114.                        * for reporting to userspace and storing
  115.                        * in superblock.
  116.                        */
  117.     struct work_struct del_work;    /* used for delayed sysfs removal */
  118.  
  119.     struct sysfs_dirent *sysfs_state; /* handle for 'state'
  120.                        * sysfs entry */
  121. };
  122.  
  123. struct mddev_s
  124. {
  125.     void                *private;
  126.     struct mdk_personality        *pers;
  127.     dev_t                unit;
  128.     int                md_minor;
  129.     struct list_head         disks;
  130.     unsigned long            flags;
  131. #define MD_CHANGE_DEVS    0    /* Some device status has changed */
  132. #define MD_CHANGE_CLEAN 1    /* transition to or from 'clean' */
  133. #define MD_CHANGE_PENDING 2    /* superblock update in progress */
  134.  
  135.     int                ro;
  136.  
  137.     struct gendisk            *gendisk;
  138.  
  139.     struct kobject            kobj;
  140.  
  141.     /* Superblock information */
  142.     int                major_version,
  143.                     minor_version,
  144.                     patch_version;
  145.     int                persistent;
  146.     int                 external;    /* metadata is
  147.                              * managed externally */
  148.     char                metadata_type[17]; /* externally set*/
  149.     int                chunk_size;
  150.     time_t                ctime, utime;
  151.     int                level, layout;
  152.     char                clevel[16];
  153.     int                raid_disks;
  154.     int                max_disks;
  155.     sector_t            size; /* used size of component devices */
  156.     sector_t            array_sectors; /* exported array size */
  157.     __u64                events;
  158.  
  159.     char                uuid[16];
  160.  
  161.     /* If the array is being reshaped, we need to record the
  162.      * new shape and an indication of where we are up to.
  163.      * This is written to the superblock.
  164.      * If reshape_position is MaxSector, then no reshape is happening (yet).
  165.      */
  166.     sector_t            reshape_position;
  167.     int                delta_disks, new_level, new_layout, new_chunk;
  168.  
  169.     struct mdk_thread_s        *thread;    /* management thread */
  170.     struct mdk_thread_s        *sync_thread;    /* doing resync or reconstruct */
  171.     sector_t            curr_resync;    /* last block scheduled */
  172.     unsigned long            resync_mark;    /* a recent timestamp */
  173.     sector_t            resync_mark_cnt;/* blocks written at resync_mark */
  174.     sector_t            curr_mark_cnt; /* blocks scheduled now */
  175.  
  176.     sector_t            resync_max_sectors; /* may be set by personality */
  177.  
  178.     sector_t            resync_mismatches; /* count of sectors where
  179.                                 * parity/replica mismatch found
  180.                                 */
  181.  
  182.     /* allow user-space to request suspension of IO to regions of the array */
  183.     sector_t            suspend_lo;
  184.     sector_t            suspend_hi;
  185.     /* if zero, use the system-wide default */
  186.     int                sync_speed_min;
  187.     int                sync_speed_max;
  188.  
  189.     /* resync even though the same disks are shared among md-devices */
  190.     int                parallel_resync;
  191.  
  192.     int                ok_start_degraded;
  193.     /* recovery/resync flags 
  194.      * NEEDED:   we might need to start a resync/recover
  195.      * RUNNING:  a thread is running, or about to be started
  196.      * SYNC:     actually doing a resync, not a recovery
  197.      * RECOVER:  doing recovery, or need to try it.
  198.      * INTR:     resync needs to be aborted for some reason
  199.      * DONE:     thread is done and is waiting to be reaped
  200.      * REQUEST:  user-space has requested a sync (used with SYNC)
  201.      * CHECK:    user-space request for for check-only, no repair
  202.      * RESHAPE:  A reshape is happening
  203.      *
  204.      * If neither SYNC or RESHAPE are set, then it is a recovery.
  205.      */
  206. #define    MD_RECOVERY_RUNNING    0
  207. #define    MD_RECOVERY_SYNC    1
  208. #define    MD_RECOVERY_RECOVER    2
  209. #define    MD_RECOVERY_INTR    3
  210. #define    MD_RECOVERY_DONE    4
  211. #define    MD_RECOVERY_NEEDED    5
  212. #define    MD_RECOVERY_REQUESTED    6
  213. #define    MD_RECOVERY_CHECK    7
  214. #define MD_RECOVERY_RESHAPE    8
  215. #define    MD_RECOVERY_FROZEN    9
  216.  
  217.     unsigned long            recovery;
  218.  
  219.     int                in_sync;    /* know to not need resync */
  220.     struct mutex            reconfig_mutex;
  221.     atomic_t            active;        /* general refcount */
  222.     atomic_t            openers;    /* number of active opens */
  223.  
  224.     int                changed;    /* true if we might need to reread partition info */
  225.     int                degraded;    /* whether md should consider
  226.                              * adding a spare
  227.                              */
  228.     int                barriers_work;    /* initialised to true, cleared as soon
  229.                              * as a barrier request to slave
  230.                              * fails.  Only supported
  231.                              */
  232.     struct bio            *biolist;     /* bios that need to be retried
  233.                              * because BIO_RW_BARRIER is not supported
  234.                              */
  235.  
  236.     atomic_t            recovery_active; /* blocks scheduled, but not written */
  237.     wait_queue_head_t        recovery_wait;
  238.     sector_t            recovery_cp;
  239.     sector_t            resync_min;    /* user requested sync
  240.                              * starts here */
  241.     sector_t            resync_max;    /* resync should pause
  242.                              * when it gets here */
  243.  
  244.     struct sysfs_dirent        *sysfs_state;    /* handle for 'array_state'
  245.                              * file in sysfs.
  246.                              */
  247.  
  248.     struct work_struct del_work;    /* used for delayed sysfs removal */
  249.  
  250.     spinlock_t            write_lock;
  251.     wait_queue_head_t        sb_wait;    /* for waiting on superblock updates */
  252.     atomic_t            pending_writes;    /* number of active superblock writes */
  253.  
  254.     unsigned int            safemode;    /* if set, update "clean" superblock
  255.                              * when no writes pending.
  256.                              */ 
  257.     unsigned int            safemode_delay;
  258.     struct timer_list        safemode_timer;
  259.     atomic_t            writes_pending; 
  260.     struct request_queue        *queue;    /* for plugging ... */
  261.  
  262.     atomic_t                        write_behind; /* outstanding async IO */
  263.     unsigned int                    max_write_behind; /* 0 = sync */
  264.  
  265.     struct bitmap                   *bitmap; /* the bitmap for the device */
  266.     struct file            *bitmap_file; /* the bitmap file */
  267.     long                bitmap_offset; /* offset from superblock of
  268.                             * start of bitmap. May be
  269.                             * negative, but not '0'
  270.                             */
  271.     long                default_bitmap_offset; /* this is the offset to use when
  272.                                 * hot-adding a bitmap.  It should
  273.                                 * eventually be settable by sysfs.
  274.                                 */
  275.  
  276.     struct list_head        all_mddevs;
  277. };
  278.  
  279.  
  280. static inline void rdev_dec_pending(mdk_rdev_t *rdev, mddev_t *mddev)
  281. {
  282.     int faulty = test_bit(Faulty, &rdev->flags);
  283.     if (atomic_dec_and_test(&rdev->nr_pending) && faulty)
  284.         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  285. }
  286.  
  287. static inline void md_sync_acct(struct block_device *bdev, unsigned long nr_sectors)
  288. {
  289.         atomic_add(nr_sectors, &bdev->bd_contains->bd_disk->sync_io);
  290. }
  291.  
  292. struct mdk_personality
  293. {
  294.     char *name;
  295.     int level;
  296.     struct list_head list;
  297.     struct module *owner;
  298.     int (*make_request)(struct request_queue *q, struct bio *bio);
  299.     int (*run)(mddev_t *mddev);
  300.     int (*stop)(mddev_t *mddev);
  301.     void (*status)(struct seq_file *seq, mddev_t *mddev);
  302.     /* error_handler must set ->faulty and clear ->in_sync
  303.      * if appropriate, and should abort recovery if needed 
  304.      */
  305.     void (*error_handler)(mddev_t *mddev, mdk_rdev_t *rdev);
  306.     int (*hot_add_disk) (mddev_t *mddev, mdk_rdev_t *rdev);
  307.     int (*hot_remove_disk) (mddev_t *mddev, int number);
  308.     int (*spare_active) (mddev_t *mddev);
  309.     sector_t (*sync_request)(mddev_t *mddev, sector_t sector_nr, int *skipped, int go_faster);
  310.     int (*resize) (mddev_t *mddev, sector_t sectors);
  311.     int (*check_reshape) (mddev_t *mddev);
  312.     int (*start_reshape) (mddev_t *mddev);
  313.     int (*reconfig) (mddev_t *mddev, int layout, int chunk_size);
  314.     /* quiesce moves between quiescence states
  315.      * 0 - fully active
  316.      * 1 - no new requests allowed
  317.      * others - reserved
  318.      */
  319.     void (*quiesce) (mddev_t *mddev, int state);
  320. };
  321.  
  322.  
  323. struct md_sysfs_entry {
  324.     struct attribute attr;
  325.     ssize_t (*show)(mddev_t *, char *);
  326.     ssize_t (*store)(mddev_t *, const char *, size_t);
  327. };
  328.  
  329.  
  330. static inline char * mdname (mddev_t * mddev)
  331. {
  332.     return mddev->gendisk ? mddev->gendisk->disk_name : "mdX";
  333. }
  334.  
  335. /*
  336.  * iterates through some rdev ringlist. It's safe to remove the
  337.  * current 'rdev'. Dont touch 'tmp' though.
  338.  */
  339. #define rdev_for_each_list(rdev, tmp, list)                \
  340.                                     \
  341.     for ((tmp) = (list).next;                    \
  342.         (rdev) = (list_entry((tmp), mdk_rdev_t, same_set)),    \
  343.             (tmp) = (tmp)->next, (tmp)->prev != &(list)    \
  344.         ; )
  345. /*
  346.  * iterates through the 'same array disks' ringlist
  347.  */
  348. #define rdev_for_each(rdev, tmp, mddev)                \
  349.     rdev_for_each_list(rdev, tmp, (mddev)->disks)
  350.  
  351. #define rdev_for_each_rcu(rdev, mddev)                \
  352.     list_for_each_entry_rcu(rdev, &((mddev)->disks), same_set)
  353.  
  354. typedef struct mdk_thread_s {
  355.     void            (*run) (mddev_t *mddev);
  356.     mddev_t            *mddev;
  357.     wait_queue_head_t    wqueue;
  358.     unsigned long           flags;
  359.     struct task_struct    *tsk;
  360.     unsigned long        timeout;
  361. } mdk_thread_t;
  362.  
  363. #define THREAD_WAKEUP  0
  364.  
  365. #define __wait_event_lock_irq(wq, condition, lock, cmd)         \
  366. do {                                    \
  367.     wait_queue_t __wait;                        \
  368.     init_waitqueue_entry(&__wait, current);                \
  369.                                     \
  370.     add_wait_queue(&wq, &__wait);                    \
  371.     for (;;) {                            \
  372.         set_current_state(TASK_UNINTERRUPTIBLE);        \
  373.         if (condition)                        \
  374.             break;                        \
  375.         spin_unlock_irq(&lock);                    \
  376.         cmd;                            \
  377.         schedule();                        \
  378.         spin_lock_irq(&lock);                    \
  379.     }                                \
  380.     current->state = TASK_RUNNING;                    \
  381.     remove_wait_queue(&wq, &__wait);                \
  382. } while (0)
  383.  
  384. #define wait_event_lock_irq(wq, condition, lock, cmd)             \
  385. do {                                    \
  386.     if (condition)                             \
  387.         break;                            \
  388.     __wait_event_lock_irq(wq, condition, lock, cmd);        \
  389. } while (0)
  390.  
  391. static inline void safe_put_page(struct page *p)
  392. {
  393.     if (p) put_page(p);
  394. }
  395.  
  396. #endif /* CONFIG_BLOCK */
  397. #endif
  398.  
  399.